# 1. 编写程序，完成以下要求：
# 提示用户进行输入数据
# 获取用户的数据数据（需要获取2个）
# my1=int(input('请输入第一个数字：'))
# my2=int(input('请输入第二个数字：'))
# 对获取的两个数字进行求和运行，并输出相应的结果
# print(my1+my2)
# 2. 编写程序，完成以下要求：
# 提示用户进行输入数据
# 获取用户输入的数据（需要获取2个）
# my3=int(input('请输入第一个数字：'))
# my4=int(input('请输入第二个数字：'))
# 对获取的两个数字进行除法运行，并输出相应的结果
# print(my3/my4)
# 3. 编写代码，完成以下信息的显示:
#     ==================================
#     =        欢迎进入到身份认证系统V1.0
#     = 1. 登录
#     = 2. 退出
#     = 3. 认证
#     = 4. 修改密码
#     ==================================
# print('''         ==================================
#          =        欢迎进入到身份认证系统V1.0
#          = 1. 登录
#          = 2. 退出
#          = 3. 认证
#          = 4. 修改密码
#          ==================================''')

# 4. 编写程序，从键盘获取一个人的信息，然后按照下面格式显示
#     ==================================
#     姓名: dongGe
#     QQ:xxxxxxx
#     手机号:131xxxxxx
#     公司地址:北京市xxxx
#     ==================================
# name = input('请输入姓名:')
# qqh = input('请输入qq号:')
# num = input('请输入手机号:')
# hometown = input('请输入公司地址:')
# print('==================================')
# print(f'''姓名:{name}
#  QQ:{qqh}
#  手机号:{num}
#  地址:{hometown}''')
# print('==================================')
# 5. 编写程序，从键盘获取用户名和密码，并使用三种格式化输出方式输出
#     亲爱的xxx，欢迎登陆 爱学习管理系统
# user=input('请输入用户名：')
# passwd=input('请输入密码：')
# print('亲爱的%s，欢迎登陆，爱学习管理系统'%(user))
# print('亲爱的{}，欢迎登陆，爱学习管理系统'.format(user))
# print(f'亲爱的{user}，欢迎登陆，爱学习管理系统')


# 分别从屏幕获取商品名称sp_name,商品数量sp_num，商品价格sp_price,
# 并分别使用三种格式化输出方式实现“我的商品是：XXX，我商品的数量是：XXX，且每件商品的价格是：XXX”
# name=input('请输入商品名称：')
# num=input('请输入商品数量:')
# price=input('请输入商品价格:')
# print('我的商品是：%s,我商品的数量是：%s，且每件商品的价格是：%s'%(name,num,price))
# print('我的商品是：{}，我商品的数量是：{}，且每件商品的价格是：{}'.format(name,num,price))
# print(f'我的商品是：{name}，我商品的数量是：{num}，且每件商品的价格是：{price}')

# # 1.定义一个元组
# abc=(20,80,5,4.5,43.0,12)
# # 分别获取第一个  第三个  最后一个
# print(abc[0])
# print(abc[2])
# print(abc[-1])
# # 仅获取从第三个开始到最后
# print(abc[2: ])
# # 仅获取每隔一个的数据
# print(abc[1: :2])
# # 反向打印
# print(abc[ : :-1])
#
# m=(10,)
# print(m,type(m))
#
# s="abcdefghi"
# 分别获取第一个  第三个  最后一个
# print(s[0])
# print(s[2])
# print(s[-1])
# 仅获取从第三个开始到最后
# print(s[2: ])
# 仅获取每隔一个的数据
# print(s[1: :2])
# 反向打印
# print(s[ : :-1])
# 乘
# s1=s*5
# print(s1)

# list1=[100,0,90,79,65,42]
# # 增追加
# list1.append(2)
# print(list1)
# # 增插入
# list1.insert(4,'手')
# print(list1)
# # 删除通过值指定
# list1.remove(79)
# print(list1)
# # 删除通过下标指定
# del list1[0]
# print(list1)
# # 清空
# # list1.clear()
# # print(list1)
# # 修
# list1[1]=12
# print(list1)

#定义一个列表  元素：姓名  性别  年龄  婚否  成绩
# name=['hou','zhang','liu','xx']
# sex=['男','女']
# age=[20,18,50,19]
# ismarry=['yes','no']
# mark=[90,10,100,80]
# print(name,sex,age,ismarry,mark)
#
# #定义一个列表  元素：姓名  性别  年龄  婚否  成绩
# stu=['h','woman',20,True,[100,100,98]]
# print(stu)
# print(list1)
# list1.reverse()
# print(list1)
# # 从小到大
# list1.sort()
# print(list1)
# # 从大到小
# list1.sort(reverse=True)
# print(list1)
#
# # 字典
# dict1={'name':'hou','age':22,'ismarry':True,'mark':[100,100,100]}
# print(dict1)
# # 增加键值对
# # dict1['sex']='woman'
# # print(dict1)
# # 删
# # del dict1['sex']
# # print(dict1)
# dict1.pop('age')
# # 修
# # dict1['name']='hgl'
# # print(dict1)
# dict1.update({'name':'Hgl'})
# print(dict1)
# # 查
# print(dict1.get('name'))
# # 获取所有键名
# print(dict1.keys())
# # 获取所有值
# print(dict1.values())
# # 获取所有键值对
# print(dict1.items())

# set集合
# set1={12,21,00,21,'abc'}
# print(set1)
# print(set1.pop())
# print(set1.pop('abc'))
# print(set1.update({21,13,9999}))
# print(set1.add('90'))
# print(set1.clear())


#字典--》元组？
# dict2=tuple({1,2,3})
# print(dict2,type(dict2))
# #字典--》列表？
# dict2=tuple((1,2,3))
# print(dict2,type(dict2))
#字典--》set()?
# dict2=tuple(set(1,2,3))
# print(dict2,type(dict2))
#字典--》字符串？
# dict2=tuple(str(1,2,3))
# print(dict2,type(dict2))
#
# list2=set([9,1,86,3,1,2,6])
# # print(list2,type(list2))
# # list2=list(set(list2))
# # print(list2,type(list2))
# # list2.sort()
# # print(list2)
#
# for i in range(1,2,3):
#     name=input('请输入用户名：')
#     age=input('请输入年龄:')
#     ismarry=input('婚否?')
# stu={'name':'hgl','age':22}
# age=stu.get('age')
# ismarry=stu.get('ismarry')
# if age<18:
#     print('年轻人!')
# elif age==18:
#     print('棒！')
# elif age==22:
#     print('更棒！')
# else:
#     print('老人!')
# if ismarry==True:
# #     print('拖家带口的老人')
# # print('分配结束！')
#
# # for i in range(1,501):
# #     print(i)
#
# # for i in range(0,501,2):
# #     print(i)
#
# # for i in range(0,501,5):
# #     print(i)
#
# # 多重
# a=b=c=d=10
# print(a,b,c,d)
# # 多元
# a,b=10,20
# print(a,b)
# # 遍历字典元素 并提取出键  值
# d={'name':'lala','age':10}
# for i in d.items():
#     print(i)
# for i in d.values():
#         print(i)
# for i in d.keys():
#     print(i)


# # 从控制台中分贝获取两个数值，将两数最大值赋给第三个变量
# num1=input('第一个数字：')
# num2=input('第二个数字：')
# num3=num1 if num1>num2 else num2
# print(num3)

# #定义一个列表，元素是 1-50之间的数值
# list1=[]
# for i in range(1,51):
#     list1.append(i)
# print(list1)

# 列表推导式简化版
# list1=[i for i in range(1,51)]
# print(list1)

#定义一个列表，元素是 1-50之间偶数值时，偶数+3的元素
# list2=[]
# for i in range(1,51):
#     if i%2==0:
#       list2.append(i+3)
#
# print(list2)

#定义一个列表，元素是 1-50之间偶数值时，偶数+3的元素,奇数时*2
# list3=[i+3 if i%2==0 else i*2 for i in range(1,51)]
# # print(list3)
#
#
# # 乘法
# for i in range(1,10):
#     print()
#     for j in range(1,i+1):
#         print(f'{j}*{i}={i*j}',end=' ')

# 冒泡排序
# list2=[1,4,8,98,90]
# for i in range(1,len(list2)):
#     for j in range(0,len(list2)-i):
#         if list2[j]>list2[j+1]:
#             l = list2[j]
#             list2[j] = list2[j+1]
#             list2[j+1] = l
# print(list2)

# while循环
# i=1
# while i<=5:
#     i=i+1
#     print('嘻嘻嘻')

# while 循环打印出列表中的元素
# i=0
# list1=[23,89,90,99,1]
# # while i<len(list1):
# #     print(list1[i])
# #     i = i + 1
# # 乘法表
# i=1
# while i<=9:
#     j=1
#     # print() 换行
#     while j<=i:
#       print(f'{j}*{i}={j*i}',end=' ')
#       j=j+1
#     i = i + 1



# list1=[90,99,60,60,60,87,86,56,43,24,15,10,100]
# for i in range(len(list1)):
#     if list1[i]==60:
#         break
#     print(list1[i])

# i=0
# sum1=0
# while i<len(list1):
#     # print(f'寻找第{i+1}')
#     if list1[i] !=60:
#         print('找到了！！')
#         i=i+1
#         continue
#     sum1=sum1+1
#     i=i+1
# print(sum1)
    # if i ==len(list1):
    #     print('找不到！！！')

# i=0
# j=0
# while i<len(list1):
#     if list1[i] ==60:
#         j=j+1
#         print(j)
#     i=i+1
#
# def find_num():
#     i = 0
#     list1=[1,2,3,4,5,6,7,8,9,90]
#     while i<len(list1):
#         # print(f'寻找第{i+1}')
#         if list1[i] !=60:
#             print('找到了！！')
#             i=i+1
#             break
#         i=i+1
#     print(list1)
# find_num()


#用户1调用时，不传任何值
#用户2调用时，传一个值
#用户3调用时，传2个值
#用户4调用时，传4个值
#函数定义时只有一个形参
# def myFun(*a):
#     print(a,type(a))
#
# def myFun1(q,*a,p=111):
#     print(q,p)
#     print(a)

# def myFun2(**v):
#     print(v,type(v))
# 自测代码块
# myFun(2,1,34)
# myFun1(99,12,23,45,56,p=12)

# v={'a':'90','b':80}
# myFun2(**v)

# # 递归函数
# def f1():
#     print('第一个f1')
#     f1()
# f1()
#
#
# def f2():
#     print('第二个')
#     f1()
# f1()

# # 5的阶乘#使用while的循环来实现n的阶乘   5!=5*4*3*2*1
# def jc(n):
#     if n < 0:
#         return "错误：阶乘仅适用于非负整数"
#     elif n == 0 or n == 1:
#         return 1
#
#     result = 1
#     c = n  # 从n开始，依次递减为n-1, n-2...1
#
#     # 用while循环实现 n * (n-1) * ... * 1 的计算
#     while c >= 1:
#         result *= c
#         # 打印当前计算步骤（以5!为例会显示5*4*3*2*1的过程）
#         print(f"当前乘数: {c}, 累计结果: {result}")
#         c -= 1  # 递减乘数
#
#     return result
#
#
# # 计算5的阶乘并展示过程
# n = 5
# print(f"{n}! 的计算过程：")
# result = jc(n)
# print(f"\n{n}! = {result}")


# 递归5的阶乘
# def jc(n=5):
#     print(f'{n}次')
#     if n>1:
#         ji=jc(n-1)*n
#         print(f'我的乘积{ji}')
#         print(f"当前n是{n}")
#         return ji
#     else:
#         return 1
# jc(3)


#类：把具有同等功能函数归为一类，
#类中有两种：属性 行为
#字母数值下划线组成，字母开头，多以大驼峰的方式
#类中的行为：类函数===》方法，，，第一个形参必须是 self
# #self  代表类自身

class DoYunSuan():
    def mySum(self,a,b):
        try:
            if isinstance(a,(int,float)) and isinstance(b,(int,float)):
                c = a + b
                if isinstance(a, (float)) or isinstance(b, (float)):
                    c=round(c,2) #四舍五入，保留两位小数
            else:
                print('非法输入！')
        except Exception as e:
            print(f'处理加法发生异常，异常信息是：{e}')
        else:
            print('未发生异常！')
            return c
        finally:
            print('最后！')

    def myJian(self,a,b):
        try:
            if isinstance(a,(int,float)) and isinstance(b,(int,float)):
                c = a - b
                if isinstance(a, (float)) or isinstance(b, (float)):
                    c=round(c,2) #四舍五入，保留两位小数
            else:
                print('非法输入！')
        except Exception as e:
            print(f'处理加法发生异常，异常信息是：{e}')
        else:
            print('未发生异常！')
            return c
        finally:
            print('最后！')

    def myCheng(self,a,b):
        try:
            if isinstance(a,(int,float)) and isinstance(b,(int,float)):
                c = a * b
                if isinstance(a, (float)) or isinstance(b, (float)):
                    c=round(c,2) #四舍五入，保留两位小数
            else:
                print('非法输入！')
        except Exception as e:
            print(f'处理加法发生异常，异常信息是：{e}')
        else:
            print('未发生异常！')
            return c
        finally:
            print('最后！')

    def myChu(self,a,b):
        try:
            if isinstance(a, (int, float)) and isinstance(b, (int, float)):
                c = a / b
                if isinstance(a, (float)) or isinstance(b, (float)):
                    c = round(c, 2)  # 四舍五入，保留两位小数
            else:
                print('非法输入！')
        except Exception as e:
            print(f'处理加法发生异常，异常信息是：{e}')
        else:
            print('未发生异常！')
            return c
        finally:
            print('最后！')
# #代码体中只有一行代码，且有返回值的函数的定义，简化成一行代码# 匿名函数:lambda 形参:返回值
#
# # 分别在当前模块及其他模块下调用 该加减乘除 方法
# def f1():

# 将类的图纸加工生产成一个实物:类的实例化==创建类的对象:类的对象
# jiSuanQ1 = DoYunSuan()
# jiSuanQ2=DoYunSuan()
# # 通过实例对象来调用某个方法:面向对象print(jiSuan01.mySum(10 20))
# print(jiSuanQi1.mySum(10,20))

#装饰器：装饰。新的需求产生，在不动原代码的情况下，实现新功能的追加，，，打补丁
# class JiSuanQi1():
#     NAME='Jisuanqi'
#     num=100
# #     魔法函数
#     def __init__(self,n):
#         print('我是初始化函数')
#         self.num=n
#         print(self.num)
  # @语法糖 ，装饰器名：：：实现源代码与装饰器的关联
    # 原理：开始调用语法糖后面的装饰器，同时 将该函数名作为参数传入,
    ##### 装饰器中的形参指向真实的函数mySum，同时得到 inner，将inner赋值给 该函数名
    # outer(ys.mySum),,,fff--->ys.mySum,====> inner,,,inner--->mySum
    # 1outer(ys.mySum)
    # 2fff=ys.mySum
    # 3 inner=outer(ys.mySum)
    # # 4 mySum=inner
    # def mySum(self,a,b):
    #     return a+b
    # def myJian(self,a,b):
    #     return a-b
    # def myCheng(self,a,b):
    #     return a*b
    # def myChu(self,a,b):
    #     return a/b

# #定义一个类:子类(父类):类的继承1 个用法
# class JiSuanQiNew(JiSuanQi1):
#     isAI=True
# #行为，功能
#     def AIsum(self ,a, b):
#         c=a+b
#         print(c)
#         return c
#
# isqNew=JiSuanQiNew(120)
#
# if __name__ == '__main__':
#     bb = JiSuanQi1(30)
#     print(bb.myChu(20,4))

















